home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / tcp_ip / wnos / wn941101 / arpcmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-10  |  5.1 KB  |  255 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include "global.h"
  4. #include "mbuf.h"
  5. #include "timer.h"
  6. #include "enet.h"
  7. #include "ax25.h"
  8. #include "arp.h"
  9. #include "netuser.h"
  10. #include "cmdparse.h"
  11. #include "commands.h"
  12.  
  13. extern int32 Arpsavetime;
  14.  
  15. char *Arptypes[] = {
  16.         "NET/ROM",
  17.         "10 Mb Ethernet",
  18.         "3 Mb Ethernet",
  19.         "AX.25",
  20.         "Pronet",
  21.         "Chaos",
  22.         "",
  23.         "Arcnet",
  24.         "Appletalk"
  25. };
  26.  
  27. static void near dumparp __ARGS((void));
  28.  
  29. static int
  30. doarpadd(argc,argv,p)
  31. int argc;
  32. char *argv[];
  33. void *p;
  34. {
  35.     int16 hardware;
  36.     int32 addr;
  37.     char *hwaddr;
  38.     struct arp_tab *ap;
  39.     struct arp_type *at;
  40.     int pub = 0;
  41.     char Nohw[] = "Unknown hardware type %s\n";
  42.  
  43.     if(*argv[0] == 'p')   /* Is this entry published? */
  44.         pub = 1;
  45.  
  46.     if((addr = resolve(argv[1])) == 0){
  47.         tprintf(Badhost,argv[1]);
  48.         return 1;
  49.     }
  50.  
  51.     /* This is a kludge. It really ought to be table driven */
  52.     switch(tolower(*argv[2])){
  53.     case 'n':    /* Net/Rom pseudo-type */
  54.         hardware = ARP_NETROM;
  55.         break;
  56.     case 'e':    /* "ether" */
  57.         hardware = ARP_ETHER;
  58.         break;
  59.     case 'a':    /* "ax25" */
  60.         switch(tolower(argv[2][1])) {
  61.         case 'x':
  62.             hardware = ARP_AX25;
  63.             break;
  64.         case 'r':
  65.             hardware = ARP_ARCNET;
  66.             break;
  67.         default:
  68.             tprintf(Nohw,argv[2]);
  69.             return -1;
  70.         }
  71.         break;
  72.     case 'm':    /* "mac appletalk" */
  73.         hardware = ARP_APPLETALK;
  74.         break;
  75.     default:
  76.         tprintf(Nohw,argv[2]);
  77.         return -1;
  78.     }
  79.     /* If an entry already exists, clear it */
  80.     if((ap = arp_lookup(hardware,addr)) != NULLARP)
  81.         arp_drop(ap);
  82.  
  83.     at = &Arp_type[hardware];
  84.     if(at->scan == NULLFP){
  85.         tputs("Attach device first\n");
  86.         return 1;
  87.     }
  88.     /* Allocate buffer for hardware address and fill with remaining args */
  89.     hwaddr = mxallocw(AXALEN);
  90.     /* Destination address */
  91.     (*at->scan)(hwaddr,argv[3]);
  92.     ap = arp_add(addr,hardware,hwaddr,pub,0);  /* Put in table */
  93.     xfree(hwaddr);                           /* Clean up */
  94.     stop_timer(&ap->timer);                 /* Make entry permanent */
  95.     set_timer(&ap->timer,0L);
  96.     return 0;
  97. }
  98.  
  99. /* Remove an ARP entry */
  100. static int
  101. doarpdrop(argc,argv,p)
  102. int argc;
  103. char *argv[];
  104. void *p;
  105. {
  106.     int16 hardware;
  107.     int32 addr;
  108.     struct arp_tab *ap;
  109.  
  110.     if((addr = resolve(argv[1])) == 0){
  111.         tprintf(Badhost,argv[1]);
  112.         return 1;
  113.     }
  114.     /* This is a kludge. It really ought to be table driven */
  115.     switch(tolower(*argv[2])){
  116.     case 'n':
  117.         hardware = ARP_NETROM;
  118.         break;
  119.     case 'e':    /* "ether" */
  120.         hardware = ARP_ETHER;
  121.         break;
  122.     case 'a':    /* "ax25" */
  123.         switch(tolower(argv[2][1])) {
  124.         case 'x':
  125.             hardware = ARP_AX25;
  126.             break;
  127.         case 'r':
  128.             hardware = ARP_ARCNET;
  129.             break;
  130.         default:
  131.             hardware = 0;
  132.             break;
  133.         }
  134.         break;
  135.     case 'm':    /* "mac appletalk" */
  136.         hardware = ARP_APPLETALK;
  137.         break;
  138.     default:
  139.         hardware = 0;
  140.         break;
  141.     }
  142.     if((ap = arp_lookup(hardware,addr)) == NULLARP)
  143.         return -1;
  144.     arp_drop(ap);
  145.     return 0;
  146. }
  147.  
  148. /* Flush all automatic entries in the arp cache */
  149. static int
  150. doarpflush(argc,argv,p)
  151. int argc;
  152. char *argv[];
  153. void *p;
  154. {
  155.     struct arp_tab *ap, *aptmp;
  156.     int i;
  157.  
  158.     for(i = 0; i < HASHMOD; i++) {
  159.         for(ap = Arp_tab[i];ap != NULLARP;ap = aptmp){
  160.             aptmp = ap->next;
  161.             if(dur_timer(&ap->timer) != 0)
  162.                 arp_drop(ap);
  163.         }
  164.     }
  165.     return 0;
  166. }
  167.  
  168. /* Dump ARP table */
  169. static void near
  170. dumparp()
  171. {
  172.     int i;
  173.     struct arp_tab *ap;
  174.     char *e = mxallocw(128);
  175.  
  176.     tprintf("received %u badtype %u bogus addr %u reqst in %u replies %u reqst out %u\n",
  177.         Arp_stat.recv,Arp_stat.badtype,Arp_stat.badaddr,
  178.         Arp_stat.inreq,Arp_stat.replies,Arp_stat.outreq);
  179.     tputs("IP addr         Type           Time Q Addr\n");
  180.  
  181.     for(i=0;i<HASHMOD;i++){
  182.         for(ap = Arp_tab[i];ap != (struct arp_tab *)NULL;ap = ap->next){
  183.             tprintf("%-16s",inet_ntoa(ap->ip_addr));
  184.             if(ap->hardware == ARP_AX25) {
  185.                 tputs("AX.25 [");
  186.                 switch(ap->flags) {
  187.                 case DATAGRAM_MODE:
  188.                     tputs("data]   ");
  189.                     break;
  190.                 case CONNECT_MODE:
  191.                     tputs("vc]     ");
  192.                     break;
  193.                 case IPCAM_MODE:
  194.                     tputs("ipcam]  ");
  195.                     break;
  196.                 default:
  197.                     tputs("def]    ");
  198.                     break;
  199.                 }
  200.             } else
  201.                 tprintf("%-15s",smsg(Arptypes,NHWTYPES,ap->hardware));
  202.  
  203.             tprintf("%-5ld",read_timer(&ap->timer)/1000L);
  204.  
  205.             if(ap->state == ARP_PENDING)
  206.                 tprintf("%-2u",len_q(ap->pending));
  207.             else
  208.                 tputs("  ");
  209.  
  210.             if(ap->state == ARP_VALID){
  211.                 if(Arp_type[ap->hardware].format != NULL) {
  212.                     (*Arp_type[ap->hardware].format)(e,ap->hw_addr);
  213.                     tputs(e);
  214.                 }
  215.             } else {
  216.                 tputs("[unknown]");
  217.             }
  218.             if(ap->pub)
  219.                 tputs(" (published)");
  220.             tputs("\n");
  221.         }
  222.     }
  223.     xfree(e);
  224.     return;
  225. }
  226.  
  227. int
  228. doarp(argc,argv,p)
  229. int argc;
  230. char *argv[];
  231. void *p;
  232. {
  233.     struct cmds Arpcmds[] = {
  234.         "add", doarpadd, 0, 4,
  235.         "arp add <hostid> ether|ax25|netrom <ether addr|callsign>",
  236.  
  237.         "drop", doarpdrop, 0, 3,
  238.         "arp drop <hostid> ether|ax25|netrom",
  239.  
  240.         "flush", doarpflush, 0, 0,
  241.         NULLCHAR,
  242.  
  243.         "publish", doarpadd, 0, 4,
  244.         "arp publish <hostid> ether|ax25|netrom <ether addr|callsign>",
  245.  
  246.         NULLCHAR,
  247.     };
  248.  
  249.     if(argc < 2) {
  250.         dumparp();
  251.         return 0;
  252.     }
  253.     return subcmd(Arpcmds,argc,argv,p);
  254. }
  255.